// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;

namespace System.Runtime.Intrinsics.X86
{
    /// <summary>Provides access to X86 AVX512BW hardware instructions via intrinsics.</summary>
    [Intrinsic]
    [CLSCompliant(false)]
    public abstract class Avx512BW : Avx512F
    {
        internal Avx512BW() { }

        /// <summary>Gets a value that indicates whether the APIs in this class are supported.</summary>
        /// <value><see langword="true" /> if the APIs are supported; otherwise, <see langword="false" />.</value>
        /// <remarks>A value of <see langword="false" /> indicates that the APIs will throw <see cref="PlatformNotSupportedException" />.</remarks>
        public static new bool IsSupported { get => IsSupported; }

        /// <summary>Provides access to the x86 AVX512BW+VL hardware instructions via intrinsics.</summary>
        [Intrinsic]
        public new abstract class VL : Avx512F.VL
        {
            internal VL() { }

            /// <summary>Gets a value that indicates whether the APIs in this class are supported.</summary>
            /// <value><see langword="true" /> if the APIs are supported; otherwise, <see langword="false" />.</value>
            /// <remarks>A value of <see langword="false" /> indicates that the APIs will throw <see cref="PlatformNotSupportedException" />.</remarks>
            public static new bool IsSupported { get => IsSupported; }

            /// <summary>
            ///   <para>__m128i _mm_mask_blendv_epu8 (__m128i a, __m128i b, __mmask16 mask)</para>
            ///   <para>  VPBLENDMB xmm1 {k1}, xmm2, xmm3/m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector128<byte> BlendVariable(Vector128<byte> left, Vector128<byte> right, Vector128<byte> mask) => BlendVariable(left, right, mask);
            /// <summary>
            ///   <para>__m128i _mm_mask_blendv_epi16 (__m128i a, __m128i b, __mmask8 mask)</para>
            ///   <para>  VPBLENDMW xmm1 {k1}, xmm2, xmm3/m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector128<short> BlendVariable(Vector128<short> left, Vector128<short> right, Vector128<short> mask) => BlendVariable(left, right, mask);
            /// <summary>
            ///   <para>__m128i _mm_mask_blendv_epi8 (__m128i a, __m128i b, __mmask16 mask)</para>
            ///   <para>  VPBLENDMB xmm1 {k1}, xmm2, xmm3/m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector128<sbyte> BlendVariable(Vector128<sbyte> left, Vector128<sbyte> right, Vector128<sbyte> mask) => BlendVariable(left, right, mask);
            /// <summary>
            ///   <para>__m128i _mm_mask_blendv_epu16 (__m128i a, __m128i b, __mmask8 mask)</para>
            ///   <para>  VPBLENDMW xmm1 {k1}, xmm2, xmm3/m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector128<ushort> BlendVariable(Vector128<ushort> left, Vector128<ushort> right, Vector128<ushort> mask) => BlendVariable(left, right, mask);

            /// <summary>
            ///   <para>__m256i _mm256_mask_blendv_epu8 (__m256i a, __m256i b, __mmask32 mask)</para>
            ///   <para>  VPBLENDMB ymm1 {k1}, ymm2, ymm3/m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector256<byte> BlendVariable(Vector256<byte> left, Vector256<byte> right, Vector256<byte> mask) => BlendVariable(left, right, mask);
            /// <summary>
            ///   <para>__m256i _mm256_mask_blendv_epi16 (__m256i a, __m256i b, __mmask16 mask)</para>
            ///   <para>  VPBLENDMW ymm1 {k1}, ymm2, ymm3/m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector256<short> BlendVariable(Vector256<short> left, Vector256<short> right, Vector256<short> mask) => BlendVariable(left, right, mask);
            /// <summary>
            ///   <para>__m256i _mm256_mask_blendv_epi8 (__m256i a, __m256i b, __mmask32 mask)</para>
            ///   <para>  VPBLENDMB ymm1 {k1}, ymm2, ymm3/m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector256<sbyte> BlendVariable(Vector256<sbyte> left, Vector256<sbyte> right, Vector256<sbyte> mask) => BlendVariable(left, right, mask);
            /// <summary>
            ///   <para>__m256i _mm256_mask_blendv_epu16 (__m256i a, __m256i b, __mmask16 mask)</para>
            ///   <para>  VPBLENDMW ymm1 {k1}, ymm2, ymm3/m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector256<ushort> BlendVariable(Vector256<ushort> left, Vector256<ushort> right, Vector256<ushort> mask) => BlendVariable(left, right, mask);

            /// <summary>
            ///   <para>__mmask16 _mm_cmpeq_epu8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(0)</para>
            /// </summary>
            public static Vector128<byte> CompareEqual(Vector128<byte> left, Vector128<byte> right) => CompareEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmpgt_epu8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(6)</para>
            /// </summary>
            public static Vector128<byte> CompareGreaterThan(Vector128<byte> left, Vector128<byte> right) => CompareGreaterThan(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmpge_epu8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(5)</para>
            /// </summary>
            public static Vector128<byte> CompareGreaterThanOrEqual(Vector128<byte> left, Vector128<byte> right) => CompareGreaterThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmplt_epu8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(1)</para>
            /// </summary>
            public static Vector128<byte> CompareLessThan(Vector128<byte> left, Vector128<byte> right) => CompareLessThan(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmple_epu8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(2)</para>
            /// </summary>
            public static Vector128<byte> CompareLessThanOrEqual(Vector128<byte> left, Vector128<byte> right) => CompareLessThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmpne_epu8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(4)</para>
            /// </summary>
            public static Vector128<byte> CompareNotEqual(Vector128<byte> left, Vector128<byte> right) => CompareNotEqual(left, right);

            /// <summary>
            ///   <para>__mmask32 _mm256_cmpeq_epu8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(0)</para>
            /// </summary>
            public static Vector256<byte> CompareEqual(Vector256<byte> left, Vector256<byte> right) => CompareEqual(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmpgt_epu8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(6)</para>
            /// </summary>
            public static Vector256<byte> CompareGreaterThan(Vector256<byte> left, Vector256<byte> right) => CompareGreaterThan(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmpge_epu8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(5)</para>
            /// </summary>
            public static Vector256<byte> CompareGreaterThanOrEqual(Vector256<byte> left, Vector256<byte> right) => CompareGreaterThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmplt_epu8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(1)</para>
            /// </summary>
            public static Vector256<byte> CompareLessThan(Vector256<byte> left, Vector256<byte> right) => CompareLessThan(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmple_epu8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(2)</para>
            /// </summary>
            public static Vector256<byte> CompareLessThanOrEqual(Vector256<byte> left, Vector256<byte> right) => CompareLessThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmpne_epu8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(4)</para>
            /// </summary>
            public static Vector256<byte> CompareNotEqual(Vector256<byte> left, Vector256<byte> right) => CompareNotEqual(left, right);

            /// <summary>
            ///   <para>__mmask8 _mm_cmpeq_epi16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(0)</para>
            /// </summary>
            public static Vector128<short> CompareEqual(Vector128<short> left, Vector128<short> right) => CompareEqual(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmpgt_epi16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(6)</para>
            /// </summary>
            public static Vector128<short> CompareGreaterThan(Vector128<short> left, Vector128<short> right) => CompareGreaterThan(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmpge_epi16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(5)</para>
            /// </summary>
            public static Vector128<short> CompareGreaterThanOrEqual(Vector128<short> left, Vector128<short> right) => CompareGreaterThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmplt_epi16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(1)</para>
            /// </summary>
            public static Vector128<short> CompareLessThan(Vector128<short> left, Vector128<short> right) => CompareLessThan(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmple_epi16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(2)</para>
            /// </summary>
            public static Vector128<short> CompareLessThanOrEqual(Vector128<short> left, Vector128<short> right) => CompareLessThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmpne_epi16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(4)</para>
            /// </summary>
            public static Vector128<short> CompareNotEqual(Vector128<short> left, Vector128<short> right) => CompareNotEqual(left, right);

            /// <summary>
            ///   <para>__mmask16 _mm256_cmpeq_epi16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(0)</para>
            /// </summary>
            public static Vector256<short> CompareEqual(Vector256<short> left, Vector256<short> right) => CompareEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmpgt_epi16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(6)</para>
            /// </summary>
            public static Vector256<short> CompareGreaterThan(Vector256<short> left, Vector256<short> right) => CompareGreaterThan(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmpge_epi16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(5)</para>
            /// </summary>
            public static Vector256<short> CompareGreaterThanOrEqual(Vector256<short> left, Vector256<short> right) => CompareGreaterThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmplt_epi16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(1)</para>
            /// </summary>
            public static Vector256<short> CompareLessThan(Vector256<short> left, Vector256<short> right) => CompareLessThan(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmple_epi16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(2)</para>
            /// </summary>
            public static Vector256<short> CompareLessThanOrEqual(Vector256<short> left, Vector256<short> right) => CompareLessThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmpne_epi16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(4)</para>
            /// </summary>
            public static Vector256<short> CompareNotEqual(Vector256<short> left, Vector256<short> right) => CompareNotEqual(left, right);

            /// <summary>
            ///   <para>__mmask16 _mm_cmpeq_epi8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(0)</para>
            /// </summary>
            public static Vector128<sbyte> CompareEqual(Vector128<sbyte> left, Vector128<sbyte> right) => CompareEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmpgt_epi8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(6)</para>
            /// </summary>
            public static Vector128<sbyte> CompareGreaterThan(Vector128<sbyte> left, Vector128<sbyte> right) => CompareGreaterThan(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmpge_epi8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(5)</para>
            /// </summary>
            public static Vector128<sbyte> CompareGreaterThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right) => CompareGreaterThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmplt_epi8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(1)</para>
            /// </summary>
            public static Vector128<sbyte> CompareLessThan(Vector128<sbyte> left, Vector128<sbyte> right) => CompareLessThan(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmple_epi8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(2)</para>
            /// </summary>
            public static Vector128<sbyte> CompareLessThanOrEqual(Vector128<sbyte> left, Vector128<sbyte> right) => CompareLessThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm_cmpne_epi8_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(4)</para>
            /// </summary>
            public static Vector128<sbyte> CompareNotEqual(Vector128<sbyte> left, Vector128<sbyte> right) => CompareNotEqual(left, right);

            /// <summary>
            ///   <para>__mmask32 _mm256_cmpeq_epi8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(0)</para>
            /// </summary>
            public static Vector256<sbyte> CompareEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareEqual(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmpgt_epi8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(6)</para>
            /// </summary>
            public static Vector256<sbyte> CompareGreaterThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThan(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmpge_epi8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(5)</para>
            /// </summary>
            public static Vector256<sbyte> CompareGreaterThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareGreaterThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmplt_epi8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(1)</para>
            /// </summary>
            public static Vector256<sbyte> CompareLessThan(Vector256<sbyte> left, Vector256<sbyte> right) => CompareLessThan(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmple_epi8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(2)</para>
            /// </summary>
            public static Vector256<sbyte> CompareLessThanOrEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareLessThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask32 _mm256_cmpne_epi8_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(4)</para>
            /// </summary>
            public static Vector256<sbyte> CompareNotEqual(Vector256<sbyte> left, Vector256<sbyte> right) => CompareNotEqual(left, right);

            /// <summary>
            ///   <para>__mmask8 _mm_cmpeq_epu16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(0)</para>
            /// </summary>
            public static Vector128<ushort> CompareEqual(Vector128<ushort> left, Vector128<ushort> right) => CompareEqual(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmpgt_epu16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(6)</para>
            /// </summary>
            public static Vector128<ushort> CompareGreaterThan(Vector128<ushort> left, Vector128<ushort> right) => CompareGreaterThan(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmpge_epu16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(5)</para>
            /// </summary>
            public static Vector128<ushort> CompareGreaterThanOrEqual(Vector128<ushort> left, Vector128<ushort> right) => CompareGreaterThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmplt_epu16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(1)</para>
            /// </summary>
            public static Vector128<ushort> CompareLessThan(Vector128<ushort> left, Vector128<ushort> right) => CompareLessThan(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmple_epu16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(2)</para>
            /// </summary>
            public static Vector128<ushort> CompareLessThanOrEqual(Vector128<ushort> left, Vector128<ushort> right) => CompareLessThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask8 _mm_cmpne_epu16_mask (__m128i a, __m128i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(4)</para>
            /// </summary>
            public static Vector128<ushort> CompareNotEqual(Vector128<ushort> left, Vector128<ushort> right) => CompareNotEqual(left, right);

            /// <summary>
            ///   <para>__mmask16 _mm256_cmpeq_epu16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(0)</para>
            /// </summary>
            public static Vector256<ushort> CompareEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmpgt_epu16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(6)</para>
            /// </summary>
            public static Vector256<ushort> CompareGreaterThan(Vector256<ushort> left, Vector256<ushort> right) => CompareGreaterThan(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmpge_epu16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(5)</para>
            /// </summary>
            public static Vector256<ushort> CompareGreaterThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareGreaterThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmplt_epu16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(1)</para>
            /// </summary>
            public static Vector256<ushort> CompareLessThan(Vector256<ushort> left, Vector256<ushort> right) => CompareLessThan(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmple_epu16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(2)</para>
            /// </summary>
            public static Vector256<ushort> CompareLessThanOrEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareLessThanOrEqual(left, right);
            /// <summary>
            ///   <para>__mmask16 _mm256_cmpne_epu16_mask (__m256i a, __m256i b)</para>
            ///   <para>  VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(4)</para>
            /// </summary>
            public static Vector256<ushort> CompareNotEqual(Vector256<ushort> left, Vector256<ushort> right) => CompareNotEqual(left, right);

            /// <summary>
            ///   <para>__m128i _mm_cvtepi16_epi8 (__m128i a)</para>
            ///   <para>  VPMOVWB xmm1/m64 {k1}{z}, xmm2</para>
            /// </summary>
            public static Vector128<byte> ConvertToVector128Byte(Vector128<short> value) => ConvertToVector128Byte(value);
            /// <summary>
            ///   <para>__m128i _mm_cvtepi16_epi8 (__m128i a)</para>
            ///   <para>  VPMOVWB xmm1/m64 {k1}{z}, xmm2</para>
            /// </summary>
            public static Vector128<byte> ConvertToVector128Byte(Vector128<ushort> value) => ConvertToVector128Byte(value);
            /// <summary>
            ///   <para>__m128i _mm256_cvtepi16_epi8 (__m256i a)</para>
            ///   <para>  VPMOVWB xmm1/m128 {k1}{z}, ymm2</para>
            /// </summary>
            public static Vector128<byte> ConvertToVector128Byte(Vector256<short> value) => ConvertToVector128Byte(value);
            /// <summary>
            ///   <para>__m128i _mm256_cvtepi16_epi8 (__m256i a)</para>
            ///   <para>  VPMOVWB xmm1/m128 {k1}{z}, ymm2</para>
            /// </summary>
            public static Vector128<byte> ConvertToVector128Byte(Vector256<ushort> value) => ConvertToVector128Byte(value);
            /// <summary>
            ///   <para>__m128i _mm_cvtusepi16_epi8 (__m128i a)</para>
            ///   <para>  VPMOVUWB xmm1/m64 {k1}{z}, xmm2</para>
            /// </summary>
            public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector128<ushort> value) => ConvertToVector128ByteWithSaturation(value);
            /// <summary>
            ///   <para>__m128i _mm256_cvtusepi16_epi8 (__m256i a)</para>
            ///   <para>  VPMOVUWB xmm1/m128 {k1}{z}, ymm2</para>
            /// </summary>
            public static Vector128<byte> ConvertToVector128ByteWithSaturation(Vector256<ushort> value) => ConvertToVector128ByteWithSaturation(value);

            /// <summary>
            ///   <para>__m128i _mm_cvtepi16_epi8 (__m128i a)</para>
            ///   <para>  VPMOVWB xmm1/m64 {k1}{z}, zmm2</para>
            /// </summary>
            public static Vector128<sbyte> ConvertToVector128SByte(Vector128<short> value) => ConvertToVector128SByte(value);
            /// <summary>
            ///   <para>__m128i _mm_cvtepi16_epi8 (__m128i a)</para>
            ///   <para>  VPMOVWB xmm1/m64 {k1}{z}, zmm2</para>
            /// </summary>
            public static Vector128<sbyte> ConvertToVector128SByte(Vector128<ushort> value) => ConvertToVector128SByte(value);
            /// <summary>
            ///   <para>__m128i _mm256_cvtepi16_epi8 (__m256i a)</para>
            ///   <para>  VPMOVWB xmm1/m128 {k1}{z}, zmm2</para>
            /// </summary>
            public static Vector128<sbyte> ConvertToVector128SByte(Vector256<short> value) => ConvertToVector128SByte(value);
            /// <summary>
            ///   <para>__m128i _mm256_cvtepi16_epi8 (__m256i a)</para>
            ///   <para>  VPMOVWB xmm1/m128 {k1}{z}, zmm2</para>
            /// </summary>
            public static Vector128<sbyte> ConvertToVector128SByte(Vector256<ushort> value) => ConvertToVector128SByte(value);
            /// <summary>
            ///   <para>__m128i _mm_cvtsepi16_epi8 (__m128i a)</para>
            ///   <para>  VPMOVSWB xmm1/m64 {k1}{z}, zmm2</para>
            /// </summary>
            public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector128<short> value) => ConvertToVector128SByteWithSaturation(value);
            /// <summary>
            ///   <para>__m128i _mm256_cvtsepi16_epi8 (__m256i a)</para>
            ///   <para>  VPMOVSWB xmm1/m128 {k1}{z}, zmm2</para>
            /// </summary>
            public static Vector128<sbyte> ConvertToVector128SByteWithSaturation(Vector256<short> value) => ConvertToVector128SByteWithSaturation(value);

            /// <summary>
            ///   <para>__m128i _mm_mask_loadu_epi8 (__m128i s, __mmask16 k, void const * mem_addr)</para>
            ///   <para>  VMOVDQU8 xmm1 {k1}{z}, m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static unsafe Vector128<byte> MaskLoad(byte* address, Vector128<byte> mask, Vector128<byte> merge) => MaskLoad(address, mask, merge);
            /// <summary>
            ///   <para>__m128i _mm_mask_loadu_epi16 (__m128i s, __mmask8 k, void const * mem_addr)</para>
            ///   <para>  VMOVDQU32 xmm1 {k1}{z}, m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static unsafe Vector128<short> MaskLoad(short* address, Vector128<short> mask, Vector128<short> merge) => MaskLoad(address, mask, merge);
            /// <summary>
            ///   <para>__m128i _mm_mask_loadu_epi8 (__m128i s, __mmask16 k, void const * mem_addr)</para>
            ///   <para>  VMOVDQU8 xmm1 {k1}{z}, m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static unsafe Vector128<sbyte> MaskLoad(sbyte* address, Vector128<sbyte> mask, Vector128<sbyte> merge) => MaskLoad(address, mask, merge);
            /// <summary>
            ///   <para>__m128i _mm_mask_loadu_epi16 (__m128i s, __mmask8 k, void const * mem_addr)</para>
            ///   <para>  VMOVDQU32 xmm1 {k1}{z}, m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static unsafe Vector128<ushort> MaskLoad(ushort* address, Vector128<ushort> mask, Vector128<ushort> merge) => MaskLoad(address, mask, merge);

            /// <summary>
            ///   <para>__m256i _mm256_mask_loadu_epi8 (__m256i s, __mmask32 k, void const * mem_addr)</para>
            ///   <para>  VMOVDQU8 ymm1 {k1}{z}, m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static unsafe Vector256<byte> MaskLoad(byte* address, Vector256<byte> mask, Vector256<byte> merge) => MaskLoad(address, mask, merge);
            /// <summary>
            ///   <para>__m256i _mm256_mask_loadu_epi16 (__m256i s, __mmask16 k, void const * mem_addr)</para>
            ///   <para>  VMOVDQU32 ymm1 {k1}{z}, m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static unsafe Vector256<short> MaskLoad(short* address, Vector256<short> mask, Vector256<short> merge) => MaskLoad(address, mask, merge);
            /// <summary>
            ///   <para>__m256i _mm256_mask_loadu_epi8 (__m256i s, __mmask32 k, void const * mem_addr)</para>
            ///   <para>  VMOVDQU8 ymm1 {k1}{z}, m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static unsafe Vector256<sbyte> MaskLoad(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> merge) => MaskLoad(address, mask, merge);
            /// <summary>
            ///   <para>__m256i _mm256_mask_loadu_epi16 (__m256i s, __mmask16 k, void const * mem_addr)</para>
            ///   <para>  VMOVDQU32 ymm1 {k1}{z}, m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static unsafe Vector256<ushort> MaskLoad(ushort* address, Vector256<ushort> mask, Vector256<ushort> merge) => MaskLoad(address, mask, merge);

            /// <summary>
            ///   <para>void _mm_mask_storeu_si128 (void * mem_addr, __mmask16 k, __m128i a)</para>
            ///   <para>  VMOVDQU8 m128 {k1}{z}, xmm1</para>
            /// </summary>
            public static unsafe void MaskStore(byte* address, Vector128<byte> mask, Vector128<byte> source) => MaskStore(address, mask, source);
            /// <summary>
            ///   <para>void _mm_mask_storeu_si128 (void * mem_addr, __mmask8 k, __m128i a)</para>
            ///   <para>  VMOVDQU16 m128 {k1}{z}, xmm1</para>
            /// </summary>
            public static unsafe void MaskStore(short* address, Vector128<short> mask, Vector128<short> source) => MaskStore(address, mask, source);
            /// <summary>
            ///   <para>void _mm_mask_storeu_si128 (void * mem_addr, __mmask16 k, __m128i a)</para>
            ///   <para>  VMOVDQU8 m128 {k1}{z}, xmm1</para>
            /// </summary>
            public static unsafe void MaskStore(sbyte* address, Vector128<sbyte> mask, Vector128<sbyte> source) => MaskStore(address, mask, source);
            /// <summary>
            ///   <para>void _mm_mask_storeu_si128 (void * mem_addr, __mmask8 k, __m128i a)</para>
            ///   <para>  VMOVDQU16 m128 {k1}{z}, xmm1</para>
            /// </summary>
            public static unsafe void MaskStore(ushort* address, Vector128<ushort> mask, Vector128<ushort> source) => MaskStore(address, mask, source);

            /// <summary>
            ///   <para>void _mm256_mask_storeu_si256 (void * mem_addr, __mmask32 k, __m256i a)</para>
            ///   <para>  VMOVDQU8 m256 {k1}{z}, ymm1</para>
            /// </summary>
            public static unsafe void MaskStore(byte* address, Vector256<byte> mask, Vector256<byte> source) => MaskStore(address, mask, source);
            /// <summary>
            ///   <para>void _mm256_mask_storeu_si256 (void * mem_addr, __mmask16 k, __m256i a)</para>
            ///   <para>  VMOVDQU16 m256 {k1}{z}, ymm1</para>
            /// </summary>
            public static unsafe void MaskStore(short* address, Vector256<short> mask, Vector256<short> source) => MaskStore(address, mask, source);
            /// <summary>
            ///   <para>void _mm256_mask_storeu_si256 (void * mem_addr, __mmask32 k, __m256i a)</para>
            ///   <para>  VMOVDQU8 m256 {k1}{z}, ymm1</para>
            /// </summary>
            public static unsafe void MaskStore(sbyte* address, Vector256<sbyte> mask, Vector256<sbyte> source) => MaskStore(address, mask, source);
            /// <summary>
            ///   <para>void _mm256_mask_storeu_si256 (void * mem_addr, __mmask16 k, __m256i a)</para>
            ///   <para>  VMOVDQU16 m256 {k1}{z}, ymm1</para>
            /// </summary>
            public static unsafe void MaskStore(ushort* address, Vector256<ushort> mask, Vector256<ushort> source) => MaskStore(address, mask, source);

            /// <summary>
            ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
            ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector128<short> PermuteVar8x16(Vector128<short> left, Vector128<short> control) => PermuteVar8x16(left, control);
            /// <summary>
            ///   <para>__m128i _mm_permutexvar_epi16 (__m128i idx, __m128i a)</para>
            ///   <para>  VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector128<ushort> PermuteVar8x16(Vector128<ushort> left, Vector128<ushort> control) => PermuteVar8x16(left, control);

            /// <summary>
            ///   <para>__m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b)</para>
            ///   <para>  VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            ///   <para>  VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            public static Vector128<short> PermuteVar8x16x2(Vector128<short> lower, Vector128<short> indices, Vector128<short> upper) => PermuteVar8x16x2(lower, indices, upper);
            /// <summary>
            ///   <para>__m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b)</para>
            ///   <para>  VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            ///   <para>  VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            public static Vector128<ushort> PermuteVar8x16x2(Vector128<ushort> lower, Vector128<ushort> indices, Vector128<ushort> upper) => PermuteVar8x16x2(lower, indices, upper);

            /// <summary>
            ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
            ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector256<short> PermuteVar16x16(Vector256<short> left, Vector256<short> control) => PermuteVar16x16(left, control);
            /// <summary>
            ///   <para>__m256i _mm256_permutexvar_epi16 (__m256i idx, __m256i a)</para>
            ///   <para>  VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
            public static Vector256<ushort> PermuteVar16x16(Vector256<ushort> left, Vector256<ushort> control) => PermuteVar16x16(left, control);

            /// <summary>
            ///   <para>__m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b)</para>
            ///   <para>  VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            ///   <para>  VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            public static Vector256<short> PermuteVar16x16x2(Vector256<short> lower, Vector256<short> indices, Vector256<short> upper) => PermuteVar16x16x2(lower, indices, upper);
            /// <summary>
            ///   <para>__m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b)</para>
            ///   <para>  VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            ///   <para>  VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            public static Vector256<ushort> PermuteVar16x16x2(Vector256<ushort> lower, Vector256<ushort> indices, Vector256<ushort> upper) => PermuteVar16x16x2(lower, indices, upper);

            /// <summary>
            ///   <para>__m128i _mm_sllv_epi16 (__m128i a, __m128i count)</para>
            ///   <para>  VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            public static Vector128<short> ShiftLeftLogicalVariable(Vector128<short> value, Vector128<ushort> count) => ShiftLeftLogicalVariable(value, count);
            /// <summary>
            ///   <para>__m128i _mm_sllv_epi16 (__m128i a, __m128i count)</para>
            ///   <para>  VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            public static Vector128<ushort> ShiftLeftLogicalVariable(Vector128<ushort> value, Vector128<ushort> count) => ShiftLeftLogicalVariable(value, count);
            /// <summary>
            ///   <para>__m256i _mm256_sllv_epi16 (__m256i a, __m256i count)</para>
            ///   <para>  VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            public static Vector256<short> ShiftLeftLogicalVariable(Vector256<short> value, Vector256<ushort> count) => ShiftLeftLogicalVariable(value, count);
            /// <summary>
            ///   <para>__m256i _mm256_sllv_epi16 (__m256i a, __m256i count)</para>
            ///   <para>  VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            public static Vector256<ushort> ShiftLeftLogicalVariable(Vector256<ushort> value, Vector256<ushort> count) => ShiftLeftLogicalVariable(value, count);

            /// <summary>
            ///   <para>__m128i _mm_srav_epi16 (__m128i a, __m128i count)</para>
            ///   <para>  VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            public static Vector128<short> ShiftRightArithmeticVariable(Vector128<short> value, Vector128<ushort> count) => ShiftRightArithmeticVariable(value, count);
            /// <summary>
            ///   <para>__m256i _mm256_srav_epi16 (__m256i a, __m256i count)</para>
            ///   <para>  VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            public static Vector256<short> ShiftRightArithmeticVariable(Vector256<short> value, Vector256<ushort> count) => ShiftRightArithmeticVariable(value, count);

            /// <summary>
            ///   <para>__m128i _mm_srlv_epi16 (__m128i a, __m128i count)</para>
            ///   <para>  VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            public static Vector128<short> ShiftRightLogicalVariable(Vector128<short> value, Vector128<ushort> count) => ShiftRightLogicalVariable(value, count);
            /// <summary>
            ///   <para>__m128i _mm_srlv_epi16 (__m128i a, __m128i count)</para>
            ///   <para>  VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            public static Vector128<ushort> ShiftRightLogicalVariable(Vector128<ushort> value, Vector128<ushort> count) => ShiftRightLogicalVariable(value, count);
            /// <summary>
            ///   <para>__m256i _mm256_srlv_epi16 (__m256i a, __m256i count)</para>
            ///   <para>  VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            public static Vector256<short> ShiftRightLogicalVariable(Vector256<short> value, Vector256<ushort> count) => ShiftRightLogicalVariable(value, count);
            /// <summary>
            ///   <para>__m256i _mm256_srlv_epi16 (__m256i a, __m256i count)</para>
            ///   <para>  VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            public static Vector256<ushort> ShiftRightLogicalVariable(Vector256<ushort> value, Vector256<ushort> count) => ShiftRightLogicalVariable(value, count);

            /// <summary>
            ///   <para>__m128i _mm_dbsad_epu8 (__m128i a, __m128i b, int imm8)</para>
            ///   <para>  VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128</para>
            /// </summary>
            public static Vector128<ushort> SumAbsoluteDifferencesInBlock32(Vector128<byte> left, Vector128<byte> right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control);
            /// <summary>
            ///   <para>__m256i _mm256_dbsad_epu8 (__m256i a, __m256i b, int imm8)</para>
            ///   <para>  VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256</para>
            /// </summary>
            public static Vector256<ushort> SumAbsoluteDifferencesInBlock32(Vector256<byte> left, Vector256<byte> right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control);
        }

        /// <summary>Provides access to the x86 AVX512BW hardware instructions, that are only available to 64-bit processes, via intrinsics.</summary>
        [Intrinsic]
        public new abstract class X64 : Avx512F.X64
        {
            internal X64() { }

            /// <summary>Gets a value that indicates whether the APIs in this class are supported.</summary>
            /// <value><see langword="true" /> if the APIs are supported; otherwise, <see langword="false" />.</value>
            /// <remarks>A value of <see langword="false" /> indicates that the APIs will throw <see cref="PlatformNotSupportedException" />.</remarks>
            public static new bool IsSupported { get => IsSupported; }
        }

        /// <summary>
        ///   <para>__m512i _mm512_abs_epi8 (__m512i a)</para>
        ///   <para>  VPABSB zmm1 {k1}{z}, zmm2/m512</para>
        /// </summary>
        public static Vector512<byte> Abs(Vector512<sbyte> value) => Abs(value);
        /// <summary>
        ///   <para>__m512i _mm512_abs_epi16 (__m512i a)</para>
        ///   <para>  VPABSW zmm1 {k1}{z}, zmm2/m512</para>
        /// </summary>
        public static Vector512<ushort> Abs(Vector512<short> value) => Abs(value);

        /// <summary>
        ///   <para>__m512i _mm512_add_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> Add(Vector512<sbyte> left, Vector512<sbyte> right) => Add(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_add_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> Add(Vector512<byte> left, Vector512<byte> right) => Add(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_add_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> Add(Vector512<short> left, Vector512<short> right) => Add(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_add_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> Add(Vector512<ushort> left, Vector512<ushort> right) => Add(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_adds_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPADDSB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> AddSaturate(Vector512<sbyte> left, Vector512<sbyte> right) => AddSaturate(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_adds_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPADDUSB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> AddSaturate(Vector512<byte> left, Vector512<byte> right) => AddSaturate(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_adds_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPADDSW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> AddSaturate(Vector512<short> left, Vector512<short> right) => AddSaturate(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_adds_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPADDUSW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> AddSaturate(Vector512<ushort> left, Vector512<ushort> right) => AddSaturate(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count)</para>
        ///   <para>  VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8</para>
        /// </summary>
        public static Vector512<sbyte> AlignRight(Vector512<sbyte> left, Vector512<sbyte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);
        /// <summary>
        ///   <para>__m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count)</para>
        ///   <para>  VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8</para>
        /// </summary>
        public static Vector512<byte> AlignRight(Vector512<byte> left, Vector512<byte> right, [ConstantExpected] byte mask) => AlignRight(left, right, mask);

        /// <summary>
        ///   <para>__m512i _mm512_avg_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> Average(Vector512<byte> left, Vector512<byte> right) => Average(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_avg_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> Average(Vector512<ushort> left, Vector512<ushort> right) => Average(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_mask_blendv_epu8 (__m512i a, __m512i b, __mmask64 mask)</para>
        ///   <para>  VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static Vector512<byte> BlendVariable(Vector512<byte> left, Vector512<byte> right, Vector512<byte> mask) => BlendVariable(left, right, mask);
        /// <summary>
        ///   <para>__m512i _mm512_mask_blendv_epi16 (__m512i a, __m512i b, __mmask32 mask)</para>
        ///   <para>  VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static Vector512<short> BlendVariable(Vector512<short> left, Vector512<short> right, Vector512<short> mask) => BlendVariable(left, right, mask);
        /// <summary>
        ///   <para>__m512i _mm512_mask_blendv_epi8 (__m512i a, __m512i b, __mmask64 mask)</para>
        ///   <para>  VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static Vector512<sbyte> BlendVariable(Vector512<sbyte> left, Vector512<sbyte> right, Vector512<sbyte> mask) => BlendVariable(left, right, mask);
        /// <summary>
        ///   <para>__m512i _mm512_mask_blendv_epu16 (__m512i a, __m512i b, __mmask32 mask)</para>
        ///   <para>  VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static Vector512<ushort> BlendVariable(Vector512<ushort> left, Vector512<ushort> right, Vector512<ushort> mask) => BlendVariable(left, right, mask);

        /// <summary>
        ///   <para>__m512i _mm512_broadcastb_epi8 (__m128i a)</para>
        ///   <para>  VPBROADCASTB zmm1 {k1}{z}, xmm2/m8</para>
        /// </summary>
        public static Vector512<byte> BroadcastScalarToVector512(Vector128<byte> value) => BroadcastScalarToVector512(value);
        /// <summary>
        ///   <para>__m512i _mm512_broadcastb_epi8 (__m128i a)</para>
        ///   <para>  VPBROADCASTB zmm1 {k1}{z}, xmm2/m8</para>
        /// </summary>
        public static Vector512<sbyte> BroadcastScalarToVector512(Vector128<sbyte> value) => BroadcastScalarToVector512(value);
        /// <summary>
        ///   <para>__m512i _mm512_broadcastw_epi16 (__m128i a)</para>
        ///   <para>  VPBROADCASTW zmm1 {k1}{z}, xmm2/m16</para>
        /// </summary>
        public static Vector512<short> BroadcastScalarToVector512(Vector128<short> value) => BroadcastScalarToVector512(value);
        /// <summary>
        ///   <para>__m512i _mm512_broadcastw_epi16 (__m128i a)</para>
        ///   <para>  VPBROADCASTW zmm1 {k1}{z}, xmm2/m16</para>
        /// </summary>
        public static Vector512<ushort> BroadcastScalarToVector512(Vector128<ushort> value) => BroadcastScalarToVector512(value);

        /// <summary>
        ///   <para>__mmask64 _mm512_cmpeq_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPEQB k1 {k2}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> CompareEqual(Vector512<byte> left, Vector512<byte> right) => CompareEqual(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmpgt_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(6)</para>
        /// </summary>
        public static Vector512<byte> CompareGreaterThan(Vector512<byte> left, Vector512<byte> right) => CompareGreaterThan(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmpge_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(5)</para>
        /// </summary>
        public static Vector512<byte> CompareGreaterThanOrEqual(Vector512<byte> left, Vector512<byte> right) => CompareGreaterThanOrEqual(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmplt_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(1)</para>
        /// </summary>
        public static Vector512<byte> CompareLessThan(Vector512<byte> left, Vector512<byte> right) => CompareLessThan(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmple_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(2)</para>
        /// </summary>
        public static Vector512<byte> CompareLessThanOrEqual(Vector512<byte> left, Vector512<byte> right) => CompareLessThanOrEqual(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmpne_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(4)</para>
        /// </summary>
        public static Vector512<byte> CompareNotEqual(Vector512<byte> left, Vector512<byte> right) => CompareNotEqual(left, right);

        /// <summary>
        ///   <para>__mmask32 _mm512_cmpeq_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPEQW k1 {k2}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> CompareEqual(Vector512<short> left, Vector512<short> right) => CompareEqual(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmpgt_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPGTW k1 {k2}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> CompareGreaterThan(Vector512<short> left, Vector512<short> right) => CompareGreaterThan(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmpge_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(5)</para>
        /// </summary>
        public static Vector512<short> CompareGreaterThanOrEqual(Vector512<short> left, Vector512<short> right) => CompareGreaterThanOrEqual(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmplt_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(1)</para>
        /// </summary>
        public static Vector512<short> CompareLessThan(Vector512<short> left, Vector512<short> right) => CompareLessThan(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmple_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(2)</para>
        /// </summary>
        public static Vector512<short> CompareLessThanOrEqual(Vector512<short> left, Vector512<short> right) => CompareLessThanOrEqual(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmpne_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(4)</para>
        /// </summary>
        public static Vector512<short> CompareNotEqual(Vector512<short> left, Vector512<short> right) => CompareNotEqual(left, right);

        /// <summary>
        ///   <para>__mmask64 _mm512_cmpeq_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPEQB k1 {k2}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> CompareEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareEqual(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmpgt_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPGTB k1 {k2}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> CompareGreaterThan(Vector512<sbyte> left, Vector512<sbyte> right) => CompareGreaterThan(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmpge_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(5)</para>
        /// </summary>
        public static Vector512<sbyte> CompareGreaterThanOrEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareGreaterThanOrEqual(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmplt_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(1)</para>
        /// </summary>
        public static Vector512<sbyte> CompareLessThan(Vector512<sbyte> left, Vector512<sbyte> right) => CompareLessThan(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmple_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(2)</para>
        /// </summary>
        public static Vector512<sbyte> CompareLessThanOrEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareLessThanOrEqual(left, right);
        /// <summary>
        ///   <para>__mmask64 _mm512_cmpne_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(4)</para>
        /// </summary>
        public static Vector512<sbyte> CompareNotEqual(Vector512<sbyte> left, Vector512<sbyte> right) => CompareNotEqual(left, right);

        /// <summary>
        ///   <para>__mmask32 _mm512_cmpeq_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPEQW k1 {k2}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> CompareEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareEqual(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmpgt_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(6)</para>
        /// </summary>
        public static Vector512<ushort> CompareGreaterThan(Vector512<ushort> left, Vector512<ushort> right) => CompareGreaterThan(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmpge_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(5)</para>
        /// </summary>
        public static Vector512<ushort> CompareGreaterThanOrEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareGreaterThanOrEqual(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmplt_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(1)</para>
        /// </summary>
        public static Vector512<ushort> CompareLessThan(Vector512<ushort> left, Vector512<ushort> right) => CompareLessThan(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmple_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(2)</para>
        /// </summary>
        public static Vector512<ushort> CompareLessThanOrEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareLessThanOrEqual(left, right);
        /// <summary>
        ///   <para>__mmask32 _mm512_cmpne_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(4)</para>
        /// </summary>
        public static Vector512<ushort> CompareNotEqual(Vector512<ushort> left, Vector512<ushort> right) => CompareNotEqual(left, right);

        /// <summary>
        ///   <para>__m256i _mm512_cvtepi16_epi8 (__m512i a)</para>
        ///   <para>  VPMOVWB ymm1/m256 {k1}{z}, zmm2</para>
        /// </summary>
        public static Vector256<byte> ConvertToVector256Byte(Vector512<short> value) => ConvertToVector256Byte(value);
        /// <summary>
        ///   <para>__m256i _mm512_cvtepi16_epi8 (__m512i a)</para>
        ///   <para>  VPMOVWB ymm1/m256 {k1}{z}, zmm2</para>
        /// </summary>
        public static Vector256<byte> ConvertToVector256Byte(Vector512<ushort> value) => ConvertToVector256Byte(value);
        /// <summary>
        ///   <para>__m256i _mm512_cvtusepi16_epi8 (__m512i a)</para>
        ///   <para>  VPMOVUWB ymm1/m256 {k1}{z}, zmm2</para>
        /// </summary>
        public static Vector256<byte> ConvertToVector256ByteWithSaturation(Vector512<ushort> value) => ConvertToVector256ByteWithSaturation(value);

        /// <summary>
        ///   <para>__m256i _mm512_cvtepi16_epi8 (__m512i a)</para>
        ///   <para>  VPMOVWB ymm1/m256 {k1}{z}, zmm2</para>
        /// </summary>
        public static Vector256<sbyte> ConvertToVector256SByte(Vector512<short> value) => ConvertToVector256SByte(value);
        /// <summary>
        ///   <para>__m256i _mm512_cvtepi16_epi8 (__m512i a)</para>
        ///   <para>  VPMOVWB ymm1/m256 {k1}{z}, zmm2</para>
        /// </summary>
        public static Vector256<sbyte> ConvertToVector256SByte(Vector512<ushort> value) => ConvertToVector256SByte(value);
        /// <summary>
        ///   <para>__m256i _mm512_cvtsepi16_epi8 (__m512i a)</para>
        ///   <para>  VPMOVSWB ymm1/m256 {k1}{z}, zmm2</para>
        /// </summary>
        public static Vector256<sbyte> ConvertToVector256SByteWithSaturation(Vector512<short> value) => ConvertToVector256SByteWithSaturation(value);

        /// <summary>
        ///   <para>__m512i _mm512_cvtepi8_epi16 (__m128i a)</para>
        ///   <para>  VPMOVSXBW zmm1 {k1}{z}, ymm2/m256</para>
        /// </summary>
        public static Vector512<short> ConvertToVector512Int16(Vector256<sbyte> value) => ConvertToVector512Int16(value);
        /// <summary>
        ///   <para>__m512i _mm512_cvtepu8_epi16 (__m128i a)</para>
        ///   <para>  VPMOVZXBW zmm1 {k1}{z}, ymm2/m256</para>
        /// </summary>
        public static Vector512<short> ConvertToVector512Int16(Vector256<byte> value) => ConvertToVector512Int16(value);
        /// <summary>
        ///   <para>__m512i _mm512_cvtepi8_epi16 (__m128i a)</para>
        ///   <para>  VPMOVSXBW zmm1 {k1}{z}, ymm2/m256</para>
        /// </summary>
        public static Vector512<ushort> ConvertToVector512UInt16(Vector256<sbyte> value) => ConvertToVector512UInt16(value);
        /// <summary>
        ///   <para>__m512i _mm512_cvtepu8_epi16 (__m128i a)</para>
        ///   <para>  VPMOVZXBW zmm1 {k1}{z}, ymm2/m256</para>
        /// </summary>
        public static Vector512<ushort> ConvertToVector512UInt16(Vector256<byte> value) => ConvertToVector512UInt16(value);

        /// <summary>
        ///   <para>__m512i _mm512_loadu_epi8 (void const * mem_addr)</para>
        ///   <para>  VMOVDQU8 zmm1, m512</para>
        /// </summary>
        public static new unsafe Vector512<sbyte> LoadVector512(sbyte* address) => LoadVector512(address);
        /// <summary>
        ///   <para>__m512i _mm512_loadu_epi8 (void const * mem_addr)</para>
        ///   <para>  VMOVDQU8 zmm1, m512</para>
        /// </summary>
        public static new unsafe Vector512<byte> LoadVector512(byte* address) => LoadVector512(address);
        /// <summary>
        ///   <para>__m512i _mm512_loadu_epi16 (void const * mem_addr)</para>
        ///   <para>  VMOVDQU16 zmm1, m512</para>
        /// </summary>
        public static new unsafe Vector512<short> LoadVector512(short* address) => LoadVector512(address);
        /// <summary>
        ///   <para>__m512i _mm512_loadu_epi16 (void const * mem_addr)</para>
        ///   <para>  VMOVDQU16 zmm1, m512</para>
        /// </summary>
        public static new unsafe Vector512<ushort> LoadVector512(ushort* address) => LoadVector512(address);

        /// <summary>
        ///   <para>__m512i _mm512_mask_loadu_epi8 (__m512i s, __mmask64 k, void const * mem_addr)</para>
        ///   <para>  VMOVDQU8 zmm1 {k1}{z}, m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static unsafe Vector512<byte> MaskLoad(byte* address, Vector512<byte> mask, Vector512<byte> merge) => MaskLoad(address, mask, merge);
        /// <summary>
        ///   <para>__m512i _mm512_mask_loadu_epi16 (__m512i s, __mmask32 k, void const * mem_addr)</para>
        ///   <para>  VMOVDQU32 zmm1 {k1}{z}, m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static unsafe Vector512<short> MaskLoad(short* address, Vector512<short> mask, Vector512<short> merge) => MaskLoad(address, mask, merge);
        /// <summary>
        ///   <para>__m512i _mm512_mask_loadu_epi8 (__m512i s, __mmask64 k, void const * mem_addr)</para>
        ///   <para>  VMOVDQU8 zmm1 {k1}{z}, m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static unsafe Vector512<sbyte> MaskLoad(sbyte* address, Vector512<sbyte> mask, Vector512<sbyte> merge) => MaskLoad(address, mask, merge);
        /// <summary>
        ///   <para>__m512i _mm512_mask_loadu_epi16 (__m512i s, __mmask32 k, void const * mem_addr)</para>
        ///   <para>  VMOVDQU32 zmm1 {k1}{z}, m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static unsafe Vector512<ushort> MaskLoad(ushort* address, Vector512<ushort> mask, Vector512<ushort> merge) => MaskLoad(address, mask, merge);

        /// <summary>
        ///   <para>void _mm512_mask_storeu_si512 (void * mem_addr, __mmask64 k, __m512i a)</para>
        ///   <para>  VMOVDQU8 m512 {k1}{z}, zmm1</para>
        /// </summary>
        public static unsafe void MaskStore(byte* address, Vector512<byte> mask, Vector512<byte> source) => MaskStore(address, mask, source);
        /// <summary>
        ///   <para>void _mm512_mask_storeu_si512 (void * mem_addr, __mmask32 k, __m512i a)</para>
        ///   <para>  VMOVDQU16 m512 {k1}{z}, zmm1</para>
        /// </summary>
        public static unsafe void MaskStore(short* address, Vector512<short> mask, Vector512<short> source) => MaskStore(address, mask, source);
        /// <summary>
        ///   <para>void _mm512_mask_storeu_si512 (void * mem_addr, __mmask64 k, __m512i a)</para>
        ///   <para>  VMOVDQU8 m512 {k1}{z}, zmm1</para>
        /// </summary>
        public static unsafe void MaskStore(sbyte* address, Vector512<sbyte> mask, Vector512<sbyte> source) => MaskStore(address, mask, source);
        /// <summary>
        ///   <para>void _mm512_mask_storeu_si512 (void * mem_addr, __mmask32 k, __m512i a)</para>
        ///   <para>  VMOVDQU16 m512 {k1}{z}, zmm1</para>
        /// </summary>
        public static unsafe void MaskStore(ushort* address, Vector512<ushort> mask, Vector512<ushort> source) => MaskStore(address, mask, source);

        /// <summary>
        ///   <para>__m512i _mm512_max_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPMAXSB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> Max(Vector512<sbyte> left, Vector512<sbyte> right) => Max(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_max_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPMAXUB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> Max(Vector512<byte> left, Vector512<byte> right) => Max(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_max_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMAXSW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> Max(Vector512<short> left, Vector512<short> right) => Max(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_max_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMAXUW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> Max(Vector512<ushort> left, Vector512<ushort> right) => Max(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_min_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPMINSB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> Min(Vector512<sbyte> left, Vector512<sbyte> right) => Min(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_min_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPMINUB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> Min(Vector512<byte> left, Vector512<byte> right) => Min(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_min_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMINSW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> Min(Vector512<short> left, Vector512<short> right) => Min(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_min_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMINUW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> Min(Vector512<ushort> left, Vector512<ushort> right) => Min(left, right);

        /// <summary>
        ///   <para>unsigned int _cvtmask32_u32 (__mmask32 a)</para>
        ///   <para>  KMOVD r32, k1</para>
        /// </summary>
        public static new int MoveMask(Vector256<byte> value) => MoveMask(value);
        /// <summary>
        ///   <para>unsigned int _cvtmask32_u32 (__mmask32 a)</para>
        ///   <para>  KMOVD r32, k1</para>
        /// </summary>
        public static new int MoveMask(Vector256<sbyte> value) => MoveMask(value);

        /// <summary>
        ///   <para>unsigned __int64 _cvtmask64_u64 (__mmask64 a)</para>
        ///   <para>  KMOVQ r64, k1</para>
        /// </summary>
        public static long MoveMask(Vector512<byte> value) => MoveMask(value);
        /// <summary>
        ///   <para>unsigned int _cvtmask32_u32 (__mmask32 a)</para>
        ///   <para>  KMOVD r32, k1</para>
        /// </summary>
        public static int MoveMask(Vector512<short> value) => MoveMask(value);
        /// <summary>
        ///   <para>unsigned __int64 _cvtmask64_u64 (__mmask64 a)</para>
        ///   <para>  KMOVQ r64, k1</para>
        /// </summary>
        public static long MoveMask(Vector512<sbyte> value) => MoveMask(value);
        /// <summary>
        ///   <para>unsigned int _cvtmask32_u32 (__mmask32 a)</para>
        ///   <para>  KMOVD r32, k1</para>
        /// </summary>
        public static int MoveMask(Vector512<ushort> value) => MoveMask(value);

        /// <summary>
        ///   <para>__m512i _mm512_madd_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMADDWD zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<int> MultiplyAddAdjacent(Vector512<short> left, Vector512<short> right) => MultiplyAddAdjacent(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_maddubs_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMADDUBSW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> MultiplyAddAdjacent(Vector512<byte> left, Vector512<sbyte> right) => MultiplyAddAdjacent(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_mulhi_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMULHW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> MultiplyHigh(Vector512<short> left, Vector512<short> right) => MultiplyHigh(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_mulhi_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMULHUW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> MultiplyHigh(Vector512<ushort> left, Vector512<ushort> right) => MultiplyHigh(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_mulhrs_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMULHRSW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> MultiplyHighRoundScale(Vector512<short> left, Vector512<short> right) => MultiplyHighRoundScale(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_mullo_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> MultiplyLow(Vector512<short> left, Vector512<short> right) => MultiplyLow(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_mullo_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> MultiplyLow(Vector512<ushort> left, Vector512<ushort> right) => MultiplyLow(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_packs_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPACKSSWB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> PackSignedSaturate(Vector512<short> left, Vector512<short> right) => PackSignedSaturate(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_packs_epi32 (__m512i a, __m512i b)</para>
        ///   <para>  VPACKSSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst</para>
        /// </summary>
        public static Vector512<short> PackSignedSaturate(Vector512<int> left, Vector512<int> right) => PackSignedSaturate(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_packus_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPACKUSWB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> PackUnsignedSaturate(Vector512<short> left, Vector512<short> right) => PackUnsignedSaturate(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_packus_epi32 (__m512i a, __m512i b)</para>
        ///   <para>  VPACKUSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst</para>
        /// </summary>
        public static Vector512<ushort> PackUnsignedSaturate(Vector512<int> left, Vector512<int> right) => PackUnsignedSaturate(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_permutexvar_epi16 (__m512i idx, __m512i a)</para>
        ///   <para>  VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static Vector512<short> PermuteVar32x16(Vector512<short> left, Vector512<short> control) => PermuteVar32x16(left, control);
        /// <summary>
        ///   <para>__m512i _mm512_permutexvar_epi16 (__m512i idx, __m512i a)</para>
        ///   <para>  VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        /// <remarks>The native and managed intrinsics have different order of parameters.</remarks>
        public static Vector512<ushort> PermuteVar32x16(Vector512<ushort> left, Vector512<ushort> control) => PermuteVar32x16(left, control);

        /// <summary>
        ///   <para>__m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b)</para>
        ///   <para>  VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        ///   <para>  VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> PermuteVar32x16x2(Vector512<short> lower, Vector512<short> indices, Vector512<short> upper) => PermuteVar32x16x2(lower, indices, upper);
        /// <summary>
        ///   <para>__m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b)</para>
        ///   <para>  VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        ///   <para>  VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> PermuteVar32x16x2(Vector512<ushort> lower, Vector512<ushort> indices, Vector512<ushort> upper) => PermuteVar32x16x2(lower, indices, upper);

        /// <summary>
        ///   <para>__m512i _mm512_sll_epi16 (__m512i a, __m128i count)</para>
        ///   <para>  VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128</para>
        /// </summary>
        public static Vector512<short> ShiftLeftLogical(Vector512<short> value, Vector128<short> count) => ShiftLeftLogical(value, count);
        /// <summary>
        ///   <para>__m512i _mm512_sll_epi16 (__m512i a, __m128i count)</para>
        ///   <para>  VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128</para>
        /// </summary>
        public static Vector512<ushort> ShiftLeftLogical(Vector512<ushort> value, Vector128<ushort> count) => ShiftLeftLogical(value, count);

        /// <summary>
        ///   <para>__m512i _mm512_slli_epi16 (__m512i a, int imm8)</para>
        ///   <para>  VPSLLW zmm1 {k1}{z}, zmm2, imm8</para>
        /// </summary>
        public static Vector512<short> ShiftLeftLogical(Vector512<short> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);
        /// <summary>
        ///   <para>__m512i _mm512_slli_epi16 (__m512i a, int imm8)</para>
        ///   <para>  VPSLLW zmm1 {k1}{z}, zmm2, imm8</para>
        /// </summary>
        public static Vector512<ushort> ShiftLeftLogical(Vector512<ushort> value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count);

        /// <summary>
        ///   <para>__m512i _mm512_bslli_epi128 (__m512i a, const int imm8)</para>
        ///   <para>  VPSLLDQ zmm1, zmm2/m512, imm8</para>
        /// </summary>
        public static Vector512<sbyte> ShiftLeftLogical128BitLane(Vector512<sbyte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);
        /// <summary>
        ///   <para>__m512i _mm512_bslli_epi128 (__m512i a, const int imm8)</para>
        ///   <para>  VPSLLDQ zmm1, zmm2/m512, imm8</para>
        /// </summary>
        public static Vector512<byte> ShiftLeftLogical128BitLane(Vector512<byte> value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes);

        /// <summary>
        ///   <para>__m512i _mm512_sllv_epi16 (__m512i a, __m512i count)</para>
        ///   <para>  VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> ShiftLeftLogicalVariable(Vector512<short> value, Vector512<ushort> count) => ShiftLeftLogicalVariable(value, count);
        /// <summary>
        ///   <para>__m512i _mm512_sllv_epi16 (__m512i a, __m512i count)</para>
        ///   <para>  VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> ShiftLeftLogicalVariable(Vector512<ushort> value, Vector512<ushort> count) => ShiftLeftLogicalVariable(value, count);

        /// <summary>
        ///   <para>_mm512_sra_epi16 (__m512i a, __m128i count)</para>
        ///   <para>  VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128</para>
        /// </summary>
        public static Vector512<short> ShiftRightArithmetic(Vector512<short> value, Vector128<short> count) => ShiftRightArithmetic(value, count);

        /// <summary>
        ///   <para>__m512i _mm512_srai_epi16 (__m512i a, int imm8)</para>
        ///   <para>  VPSRAW zmm1 {k1}{z}, zmm2, imm8</para>
        /// </summary>
        public static Vector512<short> ShiftRightArithmetic(Vector512<short> value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count);

        /// <summary>
        ///   <para>__m512i _mm512_srav_epi16 (__m512i a, __m512i count)</para>
        ///   <para>  VPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> ShiftRightArithmeticVariable(Vector512<short> value, Vector512<ushort> count) => ShiftRightArithmeticVariable(value, count);

        /// <summary>
        ///   <para>__m512i _mm512_srl_epi16 (__m512i a, __m128i count)</para>
        ///   <para>  VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128</para>
        /// </summary>
        public static Vector512<short> ShiftRightLogical(Vector512<short> value, Vector128<short> count) => ShiftRightLogical(value, count);
        /// <summary>
        ///   <para>__m512i _mm512_srl_epi16 (__m512i a, __m128i count)</para>
        ///   <para>  VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128</para>
        /// </summary>
        public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> value, Vector128<ushort> count) => ShiftRightLogical(value, count);

        /// <summary>
        ///   <para>__m512i _mm512_srli_epi16 (__m512i a, int imm8)</para>
        ///   <para>  VPSRLW zmm1 {k1}{z}, zmm2, imm8</para>
        /// </summary>
        public static Vector512<short> ShiftRightLogical(Vector512<short> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);
        /// <summary>
        ///   <para>__m512i _mm512_srli_epi16 (__m512i a, int imm8)</para>
        ///   <para>  VPSRLW zmm1 {k1}{z}, zmm2, imm8</para>
        /// </summary>
        public static Vector512<ushort> ShiftRightLogical(Vector512<ushort> value, [ConstantExpected] byte count) => ShiftRightLogical(value, count);

        /// <summary>
        ///   <para>__m512i _mm512_bsrli_epi128 (__m512i a, const int imm8)</para>
        ///   <para>  VPSRLDQ zmm1, zmm2/m128, imm8</para>
        /// </summary>
        public static Vector512<sbyte> ShiftRightLogical128BitLane(Vector512<sbyte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);
        /// <summary>
        ///   <para>__m512i _mm512_bsrli_epi128 (__m512i a, const int imm8)</para>
        ///   <para>  VPSRLDQ zmm1, zmm2/m128, imm8</para>
        /// </summary>
        public static Vector512<byte> ShiftRightLogical128BitLane(Vector512<byte> value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes);

        /// <summary>
        ///   <para>__m512i _mm512_srlv_epi16 (__m512i a, __m512i count)</para>
        ///   <para>  VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> ShiftRightLogicalVariable(Vector512<short> value, Vector512<ushort> count) => ShiftRightLogicalVariable(value, count);
        /// <summary>
        ///   <para>__m512i _mm512_srlv_epi16 (__m512i a, __m512i count)</para>
        ///   <para>  VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> ShiftRightLogicalVariable(Vector512<ushort> value, Vector512<ushort> count) => ShiftRightLogicalVariable(value, count);

        /// <summary>
        ///   <para>__m512i _mm512_shuffle_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> Shuffle(Vector512<sbyte> value, Vector512<sbyte> mask) => Shuffle(value, mask);
        /// <summary>
        ///   <para>__m512i _mm512_shuffle_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> Shuffle(Vector512<byte> value, Vector512<byte> mask) => Shuffle(value, mask);

        /// <summary>
        ///   <para>__m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8)</para>
        ///   <para>  VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8</para>
        /// </summary>
        public static Vector512<short> ShuffleHigh(Vector512<short> value, [ConstantExpected] byte control) => ShuffleHigh(value, control);
        /// <summary>
        ///   <para>__m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8)</para>
        ///   <para>  VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8</para>
        /// </summary>
        public static Vector512<ushort> ShuffleHigh(Vector512<ushort> value, [ConstantExpected] byte control) => ShuffleHigh(value, control);

        /// <summary>
        ///   <para>__m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8)</para>
        ///   <para>  VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8</para>
        /// </summary>
        public static Vector512<short> ShuffleLow(Vector512<short> value, [ConstantExpected] byte control) => ShuffleLow(value, control);
        /// <summary>
        ///   <para>__m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8)</para>
        ///   <para>  VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8</para>
        /// </summary>
        public static Vector512<ushort> ShuffleLow(Vector512<ushort> value, [ConstantExpected] byte control) => ShuffleLow(value, control);

        /// <summary>
        ///   <para>void _mm512_storeu_epi8 (void * mem_addr, __m512i a)</para>
        ///   <para>  VMOVDQU8 m512, zmm1</para>
        /// </summary>
        public static new unsafe void Store(sbyte* address, Vector512<sbyte> source) => Store(address, source);
        /// <summary>
        ///   <para>void _mm512_storeu_epi8 (void * mem_addr, __m512i a)</para>
        ///   <para>  VMOVDQU8 m512, zmm1</para>
        /// </summary>
        public static new unsafe void Store(byte* address, Vector512<byte> source) => Store(address, source);
        /// <summary>
        ///   <para>void _mm512_storeu_epi16 (void * mem_addr, __m512i a)</para>
        ///   <para>  VMOVDQU16 m512, zmm1</para>
        /// </summary>
        public static new unsafe void Store(short* address, Vector512<short> source) => Store(address, source);
        /// <summary>
        ///   <para>void _mm512_storeu_epi16 (void * mem_addr, __m512i a)</para>
        ///   <para>  VMOVDQU16 m512, zmm1</para>
        /// </summary>
        public static new unsafe void Store(ushort* address, Vector512<ushort> source) => Store(address, source);

        /// <summary>
        ///   <para>__m512i _mm512_sub_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> Subtract(Vector512<sbyte> left, Vector512<sbyte> right) => Subtract(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_sub_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> Subtract(Vector512<byte> left, Vector512<byte> right) => Subtract(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_sub_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> Subtract(Vector512<short> left, Vector512<short> right) => Subtract(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_sub_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> Subtract(Vector512<ushort> left, Vector512<ushort> right) => Subtract(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_subs_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPSUBSB zmm1 {k1}{z}, zmm2, zmm3/m128</para>
        /// </summary>
        public static Vector512<sbyte> SubtractSaturate(Vector512<sbyte> left, Vector512<sbyte> right) => SubtractSaturate(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_subs_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPSUBSW zmm1 {k1}{z}, zmm2, zmm3/m128</para>
        /// </summary>
        public static Vector512<short> SubtractSaturate(Vector512<short> left, Vector512<short> right) => SubtractSaturate(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_subs_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPSUBUSB zmm1 {k1}{z}, zmm2, zmm3/m128</para>
        /// </summary>
        public static Vector512<byte> SubtractSaturate(Vector512<byte> left, Vector512<byte> right) => SubtractSaturate(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_subs_epu16 (__m512i a, __m512i b)</para>
        ///   <para>  VPSUBUSW zmm1 {k1}{z}, zmm2, zmm3/m128</para>
        /// </summary>
        public static Vector512<ushort> SubtractSaturate(Vector512<ushort> left, Vector512<ushort> right) => SubtractSaturate(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_sad_epu8 (__m512i a, __m512i b)</para>
        ///   <para>  VPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> SumAbsoluteDifferences(Vector512<byte> left, Vector512<byte> right) => SumAbsoluteDifferences(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_dbsad_epu8 (__m512i a, __m512i b, int imm8)</para>
        ///   <para>  VDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> SumAbsoluteDifferencesInBlock32(Vector512<byte> left, Vector512<byte> right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control);

        /// <summary>
        ///   <para>__m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> UnpackHigh(Vector512<sbyte> left, Vector512<sbyte> right) => UnpackHigh(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> UnpackHigh(Vector512<byte> left, Vector512<byte> right) => UnpackHigh(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> UnpackHigh(Vector512<short> left, Vector512<short> right) => UnpackHigh(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> UnpackHigh(Vector512<ushort> left, Vector512<ushort> right) => UnpackHigh(left, right);

        /// <summary>
        ///   <para>__m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<sbyte> UnpackLow(Vector512<sbyte> left, Vector512<sbyte> right) => UnpackLow(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b)</para>
        ///   <para>  VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<byte> UnpackLow(Vector512<byte> left, Vector512<byte> right) => UnpackLow(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<short> UnpackLow(Vector512<short> left, Vector512<short> right) => UnpackLow(left, right);
        /// <summary>
        ///   <para>__m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b)</para>
        ///   <para>  VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512</para>
        /// </summary>
        public static Vector512<ushort> UnpackLow(Vector512<ushort> left, Vector512<ushort> right) => UnpackLow(left, right);
    }
}
